home *** CD-ROM | disk | FTP | other *** search
/ Gigarom 1 / Gigarom Macintosh Archives (Quantum Leap)(CDRM1080320)(1993).iso / FILES / APP / S-Z / The Regulator.cpt / The Regulator source / main.c < prev    next >
C/C++ Source or Header  |  1992-06-19  |  9KB  |  239 lines
  1. /*------------------------------------------------------------------------------
  2. #
  3. #   Apple Developer Technical Support
  4. #
  5. # SmallDaemon
  6. # A small faceless background-only application
  7. #
  8. #   main.c  -   C Source
  9. #
  10. #   Copyright © 1991 Apple Computer, Inc.
  11. #   All rights reserved.
  12. #
  13. #   Versions:   
  14. #               1.0               09/91       C.K. Haun <TR>
  15. #   
  16. #   Components:
  17. #                           main.c
  18. #                           AppleEvents.c
  19. #
  20. # This is a _very_ simple sample showing a do-nothing 
  21. # System 7.0 faceless background application.  
  22. # 
  23. # The main things to note are....
  24. # 1)  Look at the SIZE resource for the flag settings you'll
  25. #  need to let the Finder™ know that you only want to work
  26. #  in the background.
  27. # 2) Notice that you really do have your own heap and your own
  28. #  event loop.  You can do anything a foreground application
  29. #  can do, send AppleEvents, PPC stuff, anything else you'd
  30. #  like EXCEPT a graphic interface.
  31. # 3)  NOTE that no managers are started up.  You cannot start up
  32. #  Window, Menu, Dialogs, or anything else that 
  33. #  deals with the graphic front end.  Just leave them out.
  34. #  You _can_ start up QuickDraw, if you want to use some QuickDraw
  35. #  functions (like offscreen ports), but you CANNOT actually 
  36. #  do any screen drawing.
  37. #
  38. # Of course, a backgrounder can be launched from the Finder™ 
  39. # with a double-click.  However, if you'd like the backgrounder
  40. # to perform some useful service for your main application, driver,
  41. # DA, or whatever, you will want it running all the time.
  42. #  The BEST way to insure this is to install the backgrounder in the
  43. # StartUp Items folder in the system folder.  This will insure that
  44. # it is always launched, and it will also reduce memory fragmentation
  45. # since it will be installed at startup time.  You can search for it
  46. # when you need it with IPCListPorts (see the PPC toolbox documentation).
  47. # Optionally, you can use the LaunchApplication trap to launch it 
  48. # when you need it, and kill it when you're done.  But this could 
  49. # cause some multiFinder heap fragmentation.
  50. #
  51. # And remember, it's a backgrounder, you can't see it.  To kill it
  52. # use TaskIt or ProcDoggie.
  53. #
  54. # ---------------------------------------------------------------
  55. #   Use this sample as a starting point, and adapt its' routines to 
  56. #   meet the specific needs of your project.  
  57. #
  58. ------------------------------------------------------------------------------*/
  59.  
  60. /* This doesn't do much but wait for a quit event.  But, you can expand it */
  61. /* to suit whatever your needs are for a backgrounder.  */
  62. /* Be sure to look at the SIZE resource for this app to see how the */
  63. /* flags should be set for a background-only task */
  64. #include <memory.h>
  65. #include <appleevents.h>
  66. #include <events.h>
  67. #include <types.h>
  68. #include <gestaltequ.h>
  69. #include "pb.h"
  70.  
  71. /* variables */
  72. Boolean gQuit = false;
  73. EventRecord gERecord;
  74. Boolean gHasAppleEvents;
  75. unsigned long gMySleep = 120;  /* long time, long time.  Change this if  */
  76. /* you'd like to do null processing. Just keep in mind that the */
  77. /* user does NOT know that you exist, and if you are eating */
  78. /* up a bunch of time the user will not know why his or her */
  79. /* machine is slowing down. */
  80.  
  81. /* structs */
  82. /* a little struct to install handlers from.  Makes it easier to plug in */
  83. /* new handlers */
  84. struct AEinstalls {
  85.     AEEventClass theClass;
  86.     AEEventID theEvent;
  87.     EventHandlerProcPtr theProc;
  88. };
  89. typedef struct AEinstalls AEinstalls;
  90.  
  91. /* prototypes for this file */
  92. pascal OSErr AEOpenHandler(AppleEvent *messagein, AppleEvent *reply, long refIn);
  93. pascal OSErr AEOpenDocHandler(AppleEvent *messagein, AppleEvent *reply, long refIn);
  94. pascal OSErr AEPrintHandler(AppleEvent *messagein, AppleEvent *reply, long refIn);
  95. pascal OSErr AEQuitHandler(AppleEvent *messagein, AppleEvent *reply, long refIn);
  96. void DoHighLevel(EventRecord *AERecord);
  97. void InitAEStuff(void);
  98.  
  99. main()
  100. {
  101.     /* We are NOT initializing any managers.  We're in the background, with no */
  102.     /* face, we can't use windows or dialogs or menus.  If you need to talk to the */
  103.     /* user you can post a notification, or launch an application to communicate */
  104.     /* Passing an AppleEvent in the launchapplication trap could do the */
  105.     /* communication for you. */
  106.     
  107.     InitGraf((Ptr) &thePort);
  108.     /* Routine to install Apple event handlers */
  109.     InitAEStuff();
  110.     
  111.     InitPortableStuff();
  112.  
  113.     /* no nothing but high level events */
  114.     while (gQuit == false) {
  115.         WaitNextEvent(highLevelEventMask, &gERecord, gMySleep, 0);
  116.         CheckForMains();
  117.         switch (gERecord.what) {                    
  118.             case kHighLevelEvent:
  119.             DoHighLevel(&gERecord);
  120.             break;
  121.         }
  122.     }
  123. }
  124.  
  125. /* Here are the AppleEvent handlers for this background-only task. */
  126. /* Since this is a real live application, it can accept and send any */
  127. /* Apple Events you want to send or receive.  */
  128. /* In this case, the only ones that make any sense in this app are */
  129. /* 'oapp' and 'quit' */
  130.  
  131.  
  132. /* InitAEStuff checks for the availability of the AppleEvent Manager and */
  133. /* installs our event handlers. */
  134. /* if the AEM isn't around, we bail. */
  135. void InitAEStuff(void)
  136. {
  137.     static AEinstalls HandlersToInstall[] =  {
  138.          {
  139.             kCoreEventClass, kAEOpenApplication, AEOpenHandler
  140.         },  {
  141.             kCoreEventClass, kAEOpenDocuments, AEOpenDocHandler
  142.         },  {
  143.             kCoreEventClass, kAEQuitApplication, AEQuitHandler
  144.         },  {
  145.             kCoreEventClass, kAEPrintDocuments, AEPrintHandler
  146.         }, 
  147.         /* The above are the four required AppleEvents. */
  148.     };
  149.     
  150.     OSErr aevtErr = noErr;
  151.     long aLong = 0;
  152.     Boolean gHasAppleEvents = false;
  153.     /* Check this machine for AppleEvents.  If they are not here (ie not 7.0)
  154.     *   then we exit */
  155.     gHasAppleEvents = (Gestalt(gestaltAppleEventsAttr, &aLong) == noErr);
  156.     /* The following series of calls installs all our AppleEvent Handlers.
  157.     *   These handlers are added to the application event handler list that 
  158.     *   the AppleEvent manager maintains.  So, whenever an AppleEvent happens
  159.     *   and we call AEProcessEvent, the AppleEvent manager will check our
  160.     *   list of handlers and dispatch to it if there is one.
  161.     */
  162.     if (gHasAppleEvents) {
  163.         register qq;
  164.         for (qq = 0; qq < ((sizeof(HandlersToInstall) / sizeof(AEinstalls))); qq++) {
  165.             aevtErr = AEInstallEventHandler(HandlersToInstall[qq].theClass, HandlersToInstall[qq].theEvent,
  166.                                             HandlersToInstall[qq].theProc, 0, false);
  167.             if (aevtErr) {
  168.                 /* Of course, you can't tell the user why you died directly, since you have no face.  */
  169.                 /* But, you can post a notification from here to let them know. */
  170.                 ExitToShell();                              /* just fail, baby */
  171.             }
  172.         }
  173.     } else {
  174.         ExitToShell();
  175.     }
  176. }
  177.  
  178. /* end InitAEStuff */
  179.  
  180. void DoHighLevel(EventRecord *AERecord)
  181. {
  182.     /* I'm not doing any error handling here because there's not a lot */
  183.     /* I can do, just pass the errors back. */
  184.     AEProcessAppleEvent(AERecord);
  185.     
  186. }
  187.  
  188. /* end DoHighLevel */
  189.  
  190.  
  191. /* This is the standard Open Application event.   */
  192. pascal OSErr AEOpenHandler(AppleEvent *messagein, AppleEvent *reply, long refIn)
  193. {
  194. #pragma unused (messagein,reply,refIn)
  195.     /* we of course don't do anything here, since we're background only */
  196.     /* But this was a normal launch, so return noErr */
  197.     return(noErr);
  198. }
  199.  
  200. /* end AEOpenHandler */
  201.  
  202. /* Open Doc, opens our documents. */
  203. /* In this case, of course, you are in the background so you should return an error */
  204. /* here since you're not opening a document. */
  205. /* Of course, you _might_ want to open a doc, but you will probably */
  206. /* confuse the user if you do, since they will see no action as the */
  207. /*  result of their clicking on a document icon. */
  208. pascal OSErr AEOpenDocHandler(AppleEvent *messagein, AppleEvent *reply, long refIn)
  209. {
  210. #pragma unused (reply, refIn,messagein)
  211.     /* we of course don't do anything here, so tell the sender that we  */
  212.     /* didn't handle the event */
  213.     return(errAEEventNotHandled);
  214. }
  215.  
  216. /* same logic for printing */
  217. pascal OSErr AEPrintHandler(AppleEvent *messagein, AppleEvent *reply, long refIn)
  218. {
  219. #pragma unused (reply,refIn,messagein)
  220.     /* we of course don't do anything here */
  221.     return(errAEEventNotHandled);
  222. }
  223.  
  224. /* Standard Quit event handler, to handle a Quit event from the Finder, for example.  */
  225. /* ••••• DO NOT CALL EXITTOSHELL HERE ••••• or you will never have a happy life.  */
  226. pascal OSErr AEQuitHandler(AppleEvent *messagein, AppleEvent *reply, long refIn)
  227. {
  228. #pragma unused (messagein,refIn,reply)
  229.     extern Boolean Quit;
  230.     /*  This does _NOT_ quit, you */
  231.     /* should NEVER quit from an AppleEvent handler.  Calling */
  232.     /* ExitToShell here would blow up the Finder™ */
  233.     SetRest();
  234.     SetSysSleep(gSysSleep);
  235.     SetHDSleep(gHDSleep);
  236.     gQuit = true;
  237.     return(noErr);
  238. }
  239.